Java : rappels sur les classes

Membres, méthodes, constructeurs ...

Membres et méthodes

Une classe minimale

package com.maboite.monprojet; public class Humain { }

Humain utilisateur = new Humain();

Membres

Une classe peut contenir des variables membres. On parle aussi de propriétés.

Ces membres déterminent leur visibilité (public, protected, private).

package com.maboite.monprojet; public class Humain { public String nom; public int dateNaissance; }

Humain utilisateur = new Humain(); utilisateur.nom = "Robert Smith"; utilisateur.dateNaissance = 1959; int age = 2013 - utilisateur.dateNaissance; System.out.println(utilisateur.nom + " est né en " + utilisateur.dateNaissance + ", il a " + age + " ans");

Robert Smith est né en 1959, il a 54 ans

Méthodes

Une classe peut contenir des méthodes (c'est à dire des fonctions rattachées à la classe).

Ces méthodes déterminent aussi leur visibilité (public, protected, private).

package com.maboite.monprojet; public class Humain { public void manger(){ System.out.println("Miam"); } public void marcher(){ System.out.println("En avant"); } public void dormir(){ System.out.println("Bonne nuit"); } }

Humain utilisateur = new Humain(); utilisateur.marcher(); utilisateur.manger(); utilisateur.dormir();

En avant Miam Bonne nuit

Méthodes avec le même nom

Java autorise à avoir plusieurs méthodes dans la même classe avec le même nom. Les paramètres de ces méthodes ne peuvent pas êtres identiques (type, nombre et emplacement).

package com.maboite.monprojet; public class Humain { public void manger(){ System.out.println("J'aime tout"); } public void manger(Legume legume){ System.out.println("J'aime les legumes"); } public void manger(Sushi sushi){ System.out.println("J'adore les sushis"); } }

Humain utilisateur = new Humain(); Legume aubergine = new Legume(); Legume carotte = new Legume(); Sushi nigiriSushi = new Sushi(); utilisateur.manger(aubergine); utilisateur.manger(carotte); utilisateur.manger(nigiriSushi);

J'aime les legumes J'aime les legumes J'adore les sushis

Constructeur

Il est possible de définir une ou plusieurs méthodes spéciales pour chaque classe : les contructeurs.

Un constructeur sera appellé automatiquement lors de la création de l'objet (appel de new)

Si aucun constructeur n'est défini, Java en génerera un automatiquement, sans paramètre.

• Le constructeur doit avoir le nom de sa classe.
• Il ne peut pas préciser de valeur de retour.
• Il peut avoir ou non des paramètres.
• Comme n'importe quel méthode, il peut y avoir plusieurs constructeurs, avec des paramètres différents.

package com.maboite.monprojet; public class Humain { public Humain(){ System.out.println("Je viens de naitre"); } public void manger(){ System.out.println("Miam"); } }

Humain utilisateur = new Humain(); utilisateur.manger();

Je viens de naitre Miam

Une classe complete classique

package com.maboite.monprojet; public class Humain { private int dateNaissance; public Humain(){ this.dateNaissance = 2013; } public Humain(int dateNaissance){ this.dateNaissance = dateNaissance; } public void presenter(){ System.out.println("Bonjour, je suis né en " . this.dateNaissance); } }

Humain utilisateur1 = new Humain(); utilisateur1.presenter(); Humain utilisateur2 = new Humain(1981); utilisateur2.presenter();

Bonjour, je suis né en 2013 Bonjour, je suis né en 1981

Héritage et implémentation

Il est possible de construire des hiérarchies de classes grace à l'héritage et aux interfaces.

Interface

Une interface ressemble à une classe mais ne peux déclarer que des signatures de méthodes, sans corps.

Elle ne peux pas non plus déclarer de membres.

Seule, elle ne sert à rien. Elle ne peut pas être instanciée directement. Elle laisse les classes concrêtes s'occuper de l'implémentation de ses méthodes.

Une classe peut implémenter autant d'interfaces qu'elle le souhaite.

package com.maboite.monprojet; public interface Vehicule { public void accelerer(); public void freiner(); }

package com.maboite.monprojet; public classe BerlineEssence implements Vehicule { public void accelerer(){ this.augmenterDebitEssence(); } public void freiner(){ this.reduireDebitEssence(); this.allumerFeuxStop(); } public void activerEssuieGlasse(){ // } public void klaxonner(){ // } protected void augmenterDebitEssence(){ //... } protected void reduireDebitEssence(){ //... } protected void allumerFeuxStop(){ //... } }

package com.maboite.monprojet; public classe CalecheACheval implements Vehicule { public Cheval cheval; public void accelerer(){ this.cheval.donnerOrdre("hu!"); } public void freiner(){ this.cheval.bride.tirer(); } }

BerlineEssence opelCorsa = new BerlineEssence(); opelCorsa.accelerer(); opelCorsa.klaxonner(); Vehicule peugeot306 = new BerlineEssence(); peugeot306.accelerer(); Vehicule caleche = new CalecheACheval(); caleche.accelerer();

Dans un contexte donné, c'est le type de la variable qui détermine quelles méthodes et membres peuvent être appellés. Pourtant, c'est le type initial de l'instance qui determine l'implémentation qui est exécutée.

package com.maboite.monprojet; public classe Pilote { public void faireRouler(Vehicule unVehicule){ unVehicule.accelerer(); unVehicule.freiner(); unVehicule.accelerer(); unVehicule.freiner(); } }

Pilote alainProst = new Pilote(); BerlineEssence opelCorsa = new BerlineEssence(); CalecheACheval caleche = new CalecheACheval(); alainProst.faireRouler(opelCorsa); alainProst.faireRouler(caleche);

Héritage

Un classe peut hériter d'une autre. On parle de parent et d'enfant.

Un enfant ne peut avoir qu'un parent direct.

La classe enfant peut réutiliser les membres et les méthodes de ses parents qui sont définis comme public ou protected.

La classe enfant peut aussi redéfinir (écraser) des méthodes de ses parents, à condition que ces méthodes ne soit pas définies comme final.

Toutes les classes héritent de la classe Object, définie par Java.

package com.maboite.monprojet; public classe Personnage { public int pointDeVie; public int vitesse; public void deplace(){ System.out.println("Je me déplace"); } public void attaque(){ System.out.println("Je met un coup de poing"); } }

package com.maboite.monprojet; public classe Guerrier extends Personnage { public void attaque(){ System.out.println("Je met un coup de d'épée"); } }

package com.maboite.monprojet; public classe Magicien extends Personnage { public void attaque(){ System.out.println("Je lance un sort"); } public void invoquerCreatures(){ System.out.println("J'invoque des creatures"); } }

package com.maboite.monprojet; public classe Archimage extends Magicien { public void attaque(){ System.out.println("Je lance un sort puissant"); } }

Magicien gandalf = new Magicien(); Archimage saroumane = new Archimage(); Personnage aragorn = new Guerrier(); Personnage merlin = new Archimage(); gandalf.attaque(); saroumane.attaque(); aragorn.attaque(); merlin.attaque();

Je lance un sort Je lance un sort puissant Je met un coup de d'épée Je lance un sort puissant

Classes abstraite

On peut choisir de rendre une classe abstraite pour empecher la possibilité de créer des instances de cette classe. Le seul moyen de profiter de cette classe est d'en hériter.

On peut ajouter des méthodes abstraites à une classe abstraite pour obliger les classes enfants à implémenter ces méthodes (même principe que pour les interfaces).

public abstract classe Personnage { public int pointDeVie; public int vitesse; public void deplace(){ System.out.println("Je me déplace"); } public abstract void attaque(); }

package com.maboite.monprojet; public classe Guerrier extends Personnage { public void attaque(){ System.out.println("Je met un coup de d'épée"); } }

Une hierarchie de classe classique

public abstract class Forme { public float positionCentreX; public float positionCentreY; public abstract float aire() ; }

public class Carre extends Forme { public float cote; public float aire() { return cote * cote; } }

public class Cercle extends Forme { public float rayon; public float aire() { return 3.14 * rayon * rayon; } }

Statique et non statique

Il est possible de déclarer des méthodes ou des membres static.

Ils ne sont alors pas dépendant d'une instance mais de la classe.

Il n'est pas nécessaire d'instancier un objet pour utiliser ses méthodes ou ses membres statiques.

Les méthodes statiques ne peuvent pas acceder aux méthodes ou aux membres non-statiques de leur classe.

public class Personnage { public static int nombreDePersonnages=0; public void Personnage(){ nombreDePersonnages++; } }

System.out.print("Il existe " + Personnage.nombreDePersonnages + " personnages"); Personnage bob = new Personnage(); Personnage john = new Personnage(); Personnage robert = new Personnage(); Personnage jean = new Personnage(); System.out.print("Il existe " + Personnage.nombreDePersonnages + " personnages"); System.out.print("Il existe " + bob.nombreDePersonnages + " personnages"); System.out.print("Il existe " + jean.nombreDePersonnages + " personnages");

Il existe 0 personnages Il existe 4 personnages Il existe 4 personnages Il existe 4 personnages

Les classes statiques servent souvant pour rassembler des fonctions utilitaires.

public class BoiteAOutil { public static int addition(int a, int b){ return a+b; } public static int soustraction(int a, int b){ return a-b; } }

int res1 = BoiteAOutil.addition(50, 10); int res2 = BoiteAOutil.soustraction(50, 10);

A noter que plusieurs Design Patterns utilisent des méthodes statiques : le Singleton, la Factory par exemple.